// 主程序执行顺序及步骤

// onmessage 方法 加载事件传递
// 方法名称为 Events对象 子集 key 值
// 1、接收 StartMapEvent 消息，缓存ID
// 2、接收 ChangeSelectConfig 消息。缓存渲染过滤数据
// 3、接收 ChangeIndexNumber 消息。缓存经纬度渲染数据
// 4、接收 SetAllDataArray 从长链接数据中对数据进行初步处理
// 5、setInterval 中持续执行 render 事件，以进行数据加载




// 整体数据集合
var AllDataArray = [];
// 经度集合
var XIndexArray = [];
// 纬度集合
var YIndexArray = [];
// 渲染数据中 高度的 缓存数组
var HeightArray = [137];
// 渲染数据中 类型的 缓存数组
var ColorArray = [1, 2, 3];
// 事件ID 缓存（做双重控制用,暂时没遇到）
var CacheID = '';


// 内部变量，用来控制渲染第几帧的数据
var RenderIndex = null;
// 逐步显示率，用来控制大数据加载时，一次数据不能超过50W 的问题
// 将渲染数据拆分，则每次渲染数据量小于50W，
// 需要一个不阻塞进程的定时器，
// 从而达到CPU资源允许时，加载制定的数据集合
var Timer = null;





var Events = {
    /**
     * 事件ID 改变时 （暂时无效，用来为 kafka 区分用户的缓存ID）
     *
     * @param {string} ID 渲染ID
     */
    StartMapEvent(ID) {
        CacheID = ID;
        // 固定指令，清除地图渲染数据
        postMessage({ EventName: 'ClearMap' });
        // 重置渲染进度
        RenderIndex = 0;
    },
    /**
     * 当高度改变时或者当颜色类别改变时
     *
     * @param {object} data 更新缓存的数据
     */
    ChangeSelectConfig(data) {
        // 固定指令，清除地图渲染数据
        postMessage({ EventName: 'ClearMap' });
        // 更新缓存数据
        HeightArray = data.HeightArray;
        ColorArray = data.ColorArray;
        // 重置渲染进度
        RenderIndex = 0;
    },
    /**
     * 更新经纬度数组
     *
     * @param {string} string
     */
    ChangeIndexNumber(string) {
        var data = string.split('$');
        if (data[0] == CacheID) {
            // 固定指令，清除地图渲染数据
            postMessage({ EventName: 'ClearMap' });
            XIndexArray = data[2].split('|').map(item => parseFloat(item));
            YIndexArray = data[3].split('|').map(item => parseFloat(item));
            AllDataArray = [];
            RenderIndex = 0;
        };
    },
    /**
     * 当服务器发来数据时，将数据处理为可用格式
     *
     * @param {string} string
     */
    SetAllDataArray(string) {
        var data = string.split('$');
        if (data[0] == CacheID) {
            var lineArray = [];
            var _data = data.slice(2, data.length - 1);
            for (let i = 0; i < _data.length; i++) {
                const element = _data[i];
                let item = element.split('|');
                let length = (item.length - 2) / 4;
                var itemList = [];
                // 过滤掉 无用数据
                for (let y = 0; y < length; y++) {
                    if (item[y * 4 + 5] != '0') {
                        itemList.push([parseInt(item[y * 4 + 4]), parseInt(item[y * 4 + 5])]);
                    }
                }
                // 无效数据 直接不添加到渲染进程中，
                // 以减小判断和内存开销
                if (itemList.length) {
                    lineArray.push({
                        x: parseInt(item[0]),
                        y: parseInt(item[1]),
                        list: itemList
                    })
                }
            }
            AllDataArray.push(lineArray);
        }
    },
    /**
     * 真正的执行渲染，需要从 HeightArray 和 ColorArray 中过滤数据
     *
     * @param {array} data
     */
    render(data) {
        // 渲染数据处理
        // 先对 颜色数组进行排序，以保证数据稳定性
        var _ColorArray = JSON.parse(JSON.stringify(ColorArray)).sort();
        var value = [];
        for (let i = 0; i < data.length; i++) {
            const element = data[i];
            var index = 0;
            for (let i = 0; i < element.list.length; i++) {
                const item = element.list[i];
                if (HeightArray.includes(item[0])) {
                    // 备选颜色处理（目前只支持 1,2,3）
                    if (ColorArray.includes(item[1])) {
                        // 颜色数组中直接包含，返回颜色
                        index = item[1];
                    } else if (_ColorArray.length == 2 && item[1] > _ColorArray[1]) {
                        // 颜色数组中 有两个，并且颜色值比最后一个大，返回最后一个缓存数据
                        index = _ColorArray[1];
                    } else if (_ColorArray.length == 2 && item[1] < _ColorArray[1]) {
                        // 颜色数组中 有两个，并且颜色值比第一个小，返回第一个缓存数据
                        index = _ColorArray[0];
                    } else if (_ColorArray.length == 1 && item[1] > _ColorArray[0]) {
                        // 颜色数组中只有一个，并且值比颜色数组中值大，返回第一个缓存数据
                        index = _ColorArray[0];
                    }
                }
            }
            if (index != 0) {
                value.push({
                    R: [XIndexArray[element.x], YIndexArray[element.y], XIndexArray[element.x + 1], YIndexArray[element.y + 1]],
                    C: index
                })
            }
        }
        // 执行数据加载传输
        postMessage({ EventName: 'SetMapData', ID: CacheID, value: value });
    },

    /**
     * 清除缓存
     *
     */
    destroy() {
        AllDataArray = undefined;
        XIndexArray = undefined;
        YIndexArray = undefined;
        HeightArray = undefined;
        ColorArray = undefined;
        CacheID = undefined;
        RenderIndex = undefined;
        clearInterval(Timer);
        Timer = undefined;
    }
}

// 定时器
Timer = setInterval(() => {
    // 有数据，并且数据为可用状态时，执行渲染
    // 一行数据只加载一次
    if (RenderIndex != null && AllDataArray[RenderIndex]) {
        // 执行数据渲染
        Events.render(AllDataArray[RenderIndex]);
        // 序号增加
        RenderIndex++
    }
}, 200);

onmessage = function (event) {
    // 主进程消息处理
    let para = JSON.parse(event.data);
    let EventName = para.EventName;
    Events[EventName](para.Config);
}
